﻿#include <iostream>
using namespace std;
//class Person {
//
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student :public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-打折" << endl; }
//};
//
//void Func(Person* ptr)
//{
//	// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket 
//	// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。 
//	ptr.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//	Func(&ps);
//	Func(&st);
//	return 0;
//}

//class Animal
//
//{
//
//public:
//	virtual void talk() const
//
//	{}
//};
//
//class Dog : public Animal
//{
//
//public:
//	virtual void talk() const 
//
//	{
//		std::cout << "汪汪" << std::endl;
//	}
//};
//
//class Cat : public Animal
//{
//public:
//	virtual void talk() const
//
//	{
//		std::cout << "(>^ω^<)喵" << std::endl;
//	}
//};
//
//void letsHear(const Animal& animal)
//{
//	animal.talk();
//}
//
//int main()
//{
//	Cat cat;
//	Dog dog;
//	letsHear(cat);
//	letsHear(dog);
//	return 0;
//}


//class A
//
//{
//public:
//	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
//	virtual void test() { func(); }
//};
//
//class B : public A
//{
//public:
//	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
//};
//
//int main(int argc, char* argv[])
//{
//	B* p = new B;
//
//		p->test();
//	return 0;
//}

//class A
//
//{
//
//public:
//	virtual ~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//
//class B : public A {
//
//public:
//	virtual ~B()
//	{
//		cout << "~B()->delete:" << _p << endl;
//		delete _p;
//	}
//
//protected:
//	int* _p = new int[10];
//};
//
//// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能
//
//
//int main()
//{
//	A* p1 = new A;
//	A* p2 = new B;
//	delete p1;
//	delete p2;
//
//		return 0;
//}

//纯虚函数
//class car {
//public:
//	virtual void drive() = 0{}
//	
//};
//
//class Benz :public car {
//public:
//	virtual void drive() {
//		cout << "操作" << endl;
//	}
//};
//
//class Bwm :public car {
//	public:
//		virtual void drive() {
//			cout << "舒适" << endl;
//		}
//};
//int main()
//{
//	car* B = new Benz;
//	car* b = new Bwm;
//	B->drive();
//	b->drive();
//	
//}

//class person {
//	virtual void Buy() {
//
//	}
//
//	virtual void func1() {
//
//	}
//
//	virtual void func2() {
//
//	}
//private:
//	int _a1 = 1;
//	int _a2 = 2;
//};
//
//class student : public person{
//	virtual void Buy() {
//
//	}
//
//	virtual void func1() {
//
//	}
//
//	virtual void func2() {
//
//	}
//
//	virtual void func3() {
//
//	}
//private:
//	int _a3 = 3;
//	int _a4 = 4;
//};
//int main()
//{
//	person p;
//	person p1;
//	student s;
//
//}

class Base{

public:
 virtual void func1() { cout << "Base::func1" << endl; }
 virtual void func2() { cout << "Base::func2" << endl; }
 void func5() { cout << "Base::func5" << endl; }

protected:
 int a = 1;
};

class Derive : public Base
{

public:
	// 重写基类的func1 
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func1" << endl; }
	void func4() { cout << "Derive::func4" << endl; }

protected:
	int b = 2;
};




//int main()
//{
//	int i = 0;
//	static int j = 1;
//	int* p1 = new int;
//	const char* p2 = "xxxxxxxx";
//	printf("栈:%p\n", &i);
//	printf("静态区:%p\n", &j);
//	printf("堆:%p\n", p1);
//	printf("常量区:%p\n", p2);
//	Base b;
//	Derive d;
//	Base* p3 = &b;
//	Derive* p4 = &d;
//	printf("Person虚表地址:%p\n", *(int*)p3);
//	printf("Student虚表地址:%p\n", *(int*)p4);
//	printf("虚函数地址:%p\n", &Base::func1);
//	printf("普通函数地址:%p\n", &Base::func5);
//
//	return 0;
//}

#include<stdio.h>
#include<stdlib.h>
#define  MAXSIZE 100     //最大长度
#define OK 0
#define OVERFLOW -2
#define ERROR -1
typedef int Status;
typedef int ElemType;
typedef  struct
{
    ElemType* elem;      //指向数据元素的基地址
    int  length;                 //线性表的当前长度                        
}SqList;
//顺序表的初始化操作
Status InitList_Sq(SqList& L)                   //构造一 个空的顺序表L
{
    L.elem = new ElemType[MAXSIZE];   //为顺序表分配空间
    if (!L.elem) exit(OVERFLOW);           //存储分配失败
    L.length = 0;      //空表长度为0
    return OK;
}
//插入函数：在顺序表L中第i个数据元素之前插入数据元素e
Status ListInsert_Sq(SqList& L, int i, ElemType e)
{
    if (i<1 || i>L.length + 1) return ERROR;          //i值不合法
    if (L.length == MAXSIZE) return ERROR;    //当前存储空间已满     
    for (int j = L.length - 1; j >= i - 1; j--)
        L.elem[j + 1] = L.elem[j];    //插入位置及之后的元素后移
    L.elem[i - 1] = e;                     //将新元素e放入第i个位置
    ++L.length;       //表长增1
    return OK;
}

void DestroyList(SqList& L)
{
    if (L.elem) delete[]L.elem;
    //释放存储空间
}
void MergeList_Sq(SqList LA, SqList LB, SqList& LC) {
    int k = 0, r = 0;
    LC.length = LA.length + LB.length;
    //  LC.elem=new int[LC.length];
    while (k < LA.length && r < LB.length)
    {
        if (LA.elem[k] <= LB.elem[r])
            LC.elem[k + r] = LA.elem[k++];

        else
            LC.elem[k + r] = LB.elem[r++];
    }

    while (k < LA.length)
    {

        if (k == LA.length - 1) {
            LC.elem[k + r] = LA.elem[k]; break;
        }

        else LC.elem[k + r] = LA.elem[k++];
    }

    while (r < LB.length)
    {
        //
        /*if (r == LB.length - 1) {

            LC.elem[k + r] = LB.elem[k]; break;

        }*/

        

            LC.elem[k + r] = LB.elem[r++];
        

    }
}
  //MergeList_Sq
int CreatList(SqList& L, int n, int a[])
{
    for (int i = 0; i < n; i++)
    {
        L.elem[L.length] = a[i];
        L.length++;
    }
    return 0;
}
void Print_Sq(SqList L)
{
    for (int i = 0; i < L.length; i++)
    {
        if (i == 0) printf("%d", L.elem[i]);
        else printf(" %d", L.elem[i]);
    }
    printf("\n");
}
int main()
{
    SqList pa, pb, pc;
    InitList_Sq(pa);
    InitList_Sq(pb);
    InitList_Sq(pc);
    int La[] = { 1,7,8 }, Lb[] = { 2,4,6,8,10,11 };
    int j = 3, k = 6;
    CreatList(pa, j, La); CreatList(pb, k, Lb);
    MergeList_Sq(pa, pb, pc);
    printf("顺序表La元素如下：");
    Print_Sq(pa);
    printf("顺序表Lb元素如下：");
    Print_Sq(pb);
    printf("合并后的顺序表Lc元素如下：");
    Print_Sq(pc);
    return 0;
}
